package cn.stylefeng.guns.main.modular.county.utils;

import cn.stylefeng.guns.main.modular.county.modal.WeekListVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.WeekFields;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author yangdc
 * @date 2025/9/18
 */
@SuppressWarnings("unused")
public class ZhyyDateUtil {

    private static final Logger log = LoggerFactory.getLogger(ZhyyDateUtil.class);

    // 定义所有需要的 DateTimeFormatter 常量，它们是线程安全的
    public static final DateTimeFormatter YYYYMMDD_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
    public static final DateTimeFormatter YYYYMM_FORMATTER = DateTimeFormatter.ofPattern("yyyyMM");
    public static final DateTimeFormatter YYYY_MM_DD_CHINESE_FORMATTER = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
    public static final DateTimeFormatter YYYY_MM_CHINESE_FORMATTER = DateTimeFormatter.ofPattern("yyyy年MM月");
    public static final DateTimeFormatter YYYY_FORMATTER = DateTimeFormatter.ofPattern("yyyy");


    // --- 日期格式化和解析 ---

    public static String formatDayToChinese(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() != 8) {
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return yyyyMMddStr;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr, YYYYMMDD_FORMATTER);
            return date.format(YYYY_MM_DD_CHINESE_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败，错误信息: {}", yyyyMMddStr, e.getMessage());
            return yyyyMMddStr;
        }
    }

    public static String formatMonthToChinese(String yyyyMMStr) {
        if (yyyyMMStr == null || yyyyMMStr.length() != 6) {
            log.warn("无效的月份字符串yMStr: {}", yyyyMMStr);
            // throw new NullPointerException();
            return yyyyMMStr;
        }
        try {
            YearMonth yearMonth = YearMonth.parse(yyyyMMStr, YYYYMM_FORMATTER);
            return yearMonth.format(YYYY_MM_CHINESE_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析月份字符串 {} 失败，错误信息: {}", yyyyMMStr, e.getMessage());
            return yyyyMMStr;
        }
    }

    // --- 月份相关操作 ---

    /**
     * 在给定日期字符串 {@code dateStr} (yyyyMMdd) 的基础上，增加或减少指定**月份**数量 {@code monthsToAddOrSubtract}。
     *
     * @param dateStr 期望格式为 "yyyyMMdd" 的日期字符串。
     * @param monthsToAddOrSubtract 要增加或减少的月份数量 (正数增加，负数减少)。
     * @return 增加/减少月份数后的日期字符串，格式为 "yyyyMMdd"。
     * @throws java.time.format.DateTimeParseException 如果输入的日期字符串格式不正确或日期无效。
     */
    public static String addMonths(String dateStr, int monthsToAddOrSubtract) {
        // 1. 解析日期字符串为 LocalDate 对象
        // LocalDate 是不可变且线程安全的
        LocalDate date = LocalDate.parse(dateStr, YYYYMMDD_FORMATTER);
        // 2. 增加或减少月份
        // plusMonths 和 minusMonths 方法返回一个新的 LocalDate 实例，原始实例不变
        LocalDate resultDate = date.plusMonths(monthsToAddOrSubtract);
        // 3. 格式化回字符串
        return resultDate.format(YYYYMMDD_FORMATTER);
    }

    /**
     * 获取当前日期的月份 (yyyyMM)
     */
    public static String getCurrentMonth() {
        return YearMonth.now().format(YYYYMM_FORMATTER);
    }

    /**
     * 获取上一个月的年份和月份的字符串（yyyyMM）
     */
    public static String getPreviousMonth() {
        return YearMonth.now().minusMonths(1).format(YYYYMM_FORMATTER);
    }

    /**
     * 获取指定日期的上一个月份 (yyyyMM)
     * @param yyyyMMStr 格式为 yyyyMM
     */
    public static String getPreviousMonth(String yyyyMMStr) {
        if (yyyyMMStr == null || yyyyMMStr.length() != 6) {
            log.warn("无效的月份字符串yMStr: {}", yyyyMMStr);
            return null; // 或者抛出 IllegalArgumentException
        }
        try {
            YearMonth month = YearMonth.parse(yyyyMMStr, YYYYMM_FORMATTER);
            return month.minusMonths(1).format(YYYYMM_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析月份字符串 {} 失败，错误信息: {}", yyyyMMStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定日期的下一个月份 (yyyyMM)
     * @param yyyyMMStr 格式为 yyyyMM
     */
    public static String getNextMonth(String yyyyMMStr) {
        if (yyyyMMStr == null || yyyyMMStr.length() != 6) {
            log.warn("无效的月份字符串yMStr: {}", yyyyMMStr);
            return null;
        }
        try {
            YearMonth month = YearMonth.parse(yyyyMMStr, YYYYMM_FORMATTER);
            return month.plusMonths(1).format(YYYYMM_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析月份字符串 {} 失败，错误信息: {}", yyyyMMStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定月份列表
     * @param startMonthStr 起始月份，格式为 yyyyMM
     * @param count 往后推的月份数量（当前月到 i 个月之前）
     * @return 包含 yyyyMM 格式字符串的列表
     */
    public static List<String> getMonthRangeList(String startMonthStr, int count) {
        List<String> monthList = new ArrayList<>();
        try {
            YearMonth currentMonth = YearMonth.parse(startMonthStr, YYYYMM_FORMATTER);
            for (int i = 0; i <= count; i++) { // 如果是 i <= j, 则 j 可能是负数。这里根据原方法含义保留。
                monthList.add(currentMonth.plusMonths(i).format(YYYYMM_FORMATTER));
            }
        } catch (DateTimeParseException e) {
            log.error("解析月份字符串 {} 失败，或计算月份列表失败: {}", startMonthStr, e.getMessage());
        }
        return monthList;
    }


    /**
     * 获取指定日期所在月份的第一天 (yyyyMMdd)
     */
    public static String getMonthStartFormatted(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() < 6) { // 只依赖前6位即可
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr.substring(0, 6) + "01", YYYYMMDD_FORMATTER);
            return date.with(TemporalAdjusters.firstDayOfMonth()).format(YYYYMMDD_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败，错误信息: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定日期上个月的第一天 (yyyyMMdd)
     */
    public static String getPreviousMonthStartFormatted(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() < 6) { // 只依赖前6位即可
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr.substring(0, 6) + "01", YYYYMMDD_FORMATTER);
            return date.minusMonths(1).with(TemporalAdjusters.firstDayOfMonth()).format(YYYYMMDD_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败，错误信息: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定日期下个月的第一天 (yyyyMMdd)
     */
    public static String getNextMonthStartFormatted(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() < 6) { // 只依赖前6位即可
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr.substring(0, 6) + "01", YYYYMMDD_FORMATTER);
            return date.plusMonths(1).with(TemporalAdjusters.firstDayOfMonth()).format(YYYYMMDD_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败，错误信息: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定日期下个月的第一天 (yyyyMMdd)
     */
    public static String getNextMonthStartFormatted(Date date) {
        if (date == null) {
            throw new NullPointerException("Input Date cannot be null.");
        }
        // 将 java.util.Date 转换为 java.time.LocalDate
        // 需要指定时区，这里使用系统默认时区
        LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        return localDate.plusMonths(1).with(TemporalAdjusters.firstDayOfMonth()).format(YYYYMMDD_FORMATTER);
    }

    /**
     * 获取指定日期所在月份的最后一天 (yyyyMMdd)
     */
    public static String getMonthEndFormatted(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() < 6) {
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr.substring(0, 6) + "01", YYYYMMDD_FORMATTER);
            return date.with(TemporalAdjusters.lastDayOfMonth()).format(YYYYMMDD_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败，错误信息: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取给定日期所在月份的最后一天，并以 yyyyMMdd 格式返回。
     *
     * @param date 要处理的日期。
     * @return 给定日期所在月份的最后一天的字符串，格式为 yyyyMMdd。
     * @throws NullPointerException 如果传入的 date 为 null。
     */
    public static String getMonthEndFormatted(Date date) {
        if (date == null) {
            throw new NullPointerException("Input Date cannot be null.");
        }
        // 将 java.util.Date 转换为 java.time.LocalDate
        // 需要指定时区，这里使用系统默认时区
        LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        return localDate.with(TemporalAdjusters.lastDayOfMonth()).format(YYYYMMDD_FORMATTER);
    }

    /**
     * 获取给定日期所在月份的第一天，并以 yyyyMMdd 格式返回。
     *
     * @param date 要处理的日期。
     * @return 给定日期所在月份的第一天的字符串，格式为 yyyyMMdd。
     * @throws NullPointerException 如果传入的 date 为 null。
     */
    public static String getMonthStartFormatted(Date date) {
        if (date == null) {
            throw new NullPointerException("Input Date cannot be null.");
        }
        // 将 java.util.Date 转换为 java.time.LocalDate
        // 需要指定时区，这里使用系统默认时区
        LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        // 获取月份的第一天
        LocalDate firstDayOfMonth = localDate.withDayOfMonth(1);
        // 格式化为 yyyyMMdd 字符串
        return firstDayOfMonth.format(YYYYMMDD_FORMATTER);
    }

    // --- 年度相关操作 ---

    /**
     * 获取指定月份所在年份的第一月 (yyyyMM)
     */
    public static String getYearFirstMonth(String yyyyMMStr) {
        if (yyyyMMStr == null || yyyyMMStr.length() < 4) return null;
        return yyyyMMStr.substring(0, 4) + "01";
    }

    /**
     * 获取指定月份所在年份的最后一月 (yyyyMM)
     */
    public static String getYearLastMonth(String yyyyMMStr) {
        if (yyyyMMStr == null || yyyyMMStr.length() < 4) return null;
        return yyyyMMStr.substring(0, 4) + "12";
    }

    /**
     * 获取指定月份所在年份的前一年的第一月 (yyyyMM)
     */
    public static String getPreviousYearFirstMonth(String yyyyMMStr) {
        if (yyyyMMStr == null || yyyyMMStr.length() < 4) return null;
        try {
            int year = Integer.parseInt(yyyyMMStr.substring(0, 4));
            return (year - 1) + "01";
        } catch (NumberFormatException e) {
            log.error("解析年份字符串 {} 失败: {}", yyyyMMStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定月份所在年份的前一年的最后一月 (yyyyMM)
     */
    public static String getPreviousYearLastMonth(String yyyyMMStr) {
        if (yyyyMMStr == null || yyyyMMStr.length() < 4) return null;
        try {
            int year = Integer.parseInt(yyyyMMStr.substring(0, 4));
            return (year - 1) + "12";
        } catch (NumberFormatException e) {
            log.error("解析年份字符串 {} 失败: {}", yyyyMMStr, e.getMessage());
            return null;
        }
    }

    // --- 周相关操作 ---

    /**
     * 获取指定日期所在周的星期一 (yyyyMMdd)
     */
    public static String getWeekMonday(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() != 8) {
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr, YYYYMMDD_FORMATTER);
            return date.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)).format(YYYYMMDD_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败, 错误: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定日期所在周的星期日 (yyyyMMdd)
     */
    public static String getWeekSunday(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() != 8) {
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr, YYYYMMDD_FORMATTER);
            return date.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY)).format(YYYYMMDD_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败, 错误: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定日期所在月的某一周的开始日期 (按照自定义规则)
     * 1-7日 -> 1日
     * 8-14日 -> 8日
     * 15-21日 -> 15日
     * 22-28日 -> 22日
     * 29-31日 -> 29日
     */
    public static String getCustomWeekStartDayInMonth(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() != 8) {
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr, YYYYMMDD_FORMATTER);
            int dayOfMonth = date.getDayOfMonth();
            String ymStr = date.format(YYYYMM_FORMATTER);
            String startDayStr;
            if (dayOfMonth >= 1 && dayOfMonth <= 7) {
                startDayStr = "01";
            } else if (dayOfMonth >= 8 && dayOfMonth <= 14) {
                startDayStr = "08";
            } else if (dayOfMonth >= 15 && dayOfMonth <= 21) {
                startDayStr = "15";
            } else if (dayOfMonth >= 22 && dayOfMonth <= 28) {
                startDayStr = "22";
            } else { // 29-31
                startDayStr = "29";
            }
            return ymStr + startDayStr;
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败, 错误: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }

    /**
     * 获取指定日期所在月的某一周的结束日期 (按照自定义规则)
     * 1-7日 -> 7日
     * 8-14日 -> 14日
     * 15-21日 -> 21日
     * 22-31日 -> 28日 (如果29日到月底, 则直接取月底)
     */
    public static String getCustomWeekEndDayInMonth(String yyyyMMddStr) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() != 8) {
            log.warn("无效的日期字符串yMMddStr: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr, YYYYMMDD_FORMATTER);
            int dayOfMonth = date.getDayOfMonth();
            String ymStr = date.format(YYYYMM_FORMATTER);
            String endDayStr;
            if (dayOfMonth >= 1 && dayOfMonth <= 7) {
                endDayStr = "07";
            } else if (dayOfMonth >= 8 && dayOfMonth <= 14) {
                endDayStr = "14";
            } else if (dayOfMonth >= 15 && dayOfMonth <= 21) {
                endDayStr = "21";
            } else { // 22-31日
                endDayStr = "28"; // 约定为28日，如果月底超过28日
            }
            // 考虑周的结束可能超出当月实际天数，或达到月底
            LocalDate calculatedEndDate = LocalDate.parse(ymStr + endDayStr, YYYYMMDD_FORMATTER);
            if (calculatedEndDate.isAfter(date.with(TemporalAdjusters.lastDayOfMonth()))) {
                // 如果计算出的结束日期超过了当月实际的最后一天，则取当月最后一天
                return date.with(TemporalAdjusters.lastDayOfMonth()).format(YYYYMMDD_FORMATTER);
            }
            return calculatedEndDate.format(YYYYMMDD_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 失败, 错误: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }

    /**
     * 自定义 addDay 方法，兼容旧逻辑中的 "如果29日,则返回次月1日"
     * @param yyyyMMddStr 日期字符串，格式 yyyyMMdd
     * @param daysToAdd 要增加的天数
     */
    public static String addDaysSpecial(String yyyyMMddStr, int daysToAdd) {
        if (yyyyMMddStr == null || yyyyMMddStr.length() != 8) {
            log.warn("无效日期字符串: {}", yyyyMMddStr);
            return null;
        }
        try {
            LocalDate date = LocalDate.parse(yyyyMMddStr, YYYYMMDD_FORMATTER);
            LocalDate newDate = date.plusDays(daysToAdd);

            // 如果 newDate 的天是29日（假设这个特殊逻辑仅在加法后产生），则返回次月1日
            if (newDate.getDayOfMonth() == 29 && daysToAdd > 0) { // 假设只在增加日期时有此逻辑
                newDate = newDate.plusMonths(1).withDayOfMonth(1);
            }
            return newDate.format(YYYYMMDD_FORMATTER);
        } catch (DateTimeParseException e) {
            log.error("解析或操作日期 {} 失败，错误: {}", yyyyMMddStr, e.getMessage());
            return null;
        }
    }


    /**
     * 获取指定日期在本年的周数 (ISO标准，周一为一周开始)
     */
    public static int getIsoWeekOfYear(LocalDate date) {
        if (date == null) return 0;
        return date.get(WeekFields.ISO.weekOfYear()); // ISO标准：周一开始，第一周至少有4天
    }

    /**
     * 检查是否是闰年
     */
    public static boolean isLeapYear(int year) {
        // return LocalDate.of(year, 1, 1).isLeapYear();
        return Year.of(year).isLeap();
    }

    /**
     * 将 Excel 的双精度日期转换为 java.util.Date（兼容老接口）。
     * 这里保留了原代码对本地时区偏移的处理以与历史实现一致。
     */
    public static Date doubleToDate(Double dVal) {
        if (dVal == null) return null;
        java.util.Date tDate = new java.util.Date();
        java.util.Calendar cal = java.util.Calendar.getInstance();
        cal.setTime(tDate);
        long localOffset = (cal.get(java.util.Calendar.ZONE_OFFSET) + cal.get(java.util.Calendar.DST_OFFSET));
        long time = (long) ((dVal - 25569) * 24 * 3600 * 1000 + localOffset);
        return new java.util.Date(time);
    }

    /**
     * 另一种 Excel 双精度日期转换（基于 days 从 1900-01-00 起算），兼容老实现。
     */
    public static Date excelDoubleToDate(Double dateDouble) {
        if (dateDouble == null) {
            return null;
        }
        int days = dateDouble.intValue();
        java.util.Calendar calendar = java.util.Calendar.getInstance();
        calendar.set(1900, java.util.Calendar.JANUARY, 0);
        calendar.add(java.util.Calendar.DAY_OF_YEAR, days);
        return calendar.getTime();
    }

    /**
     * 检查字符串是否为有效的 yyyyMMdd 或 Excel 数字日期（5位）
     */
    public static boolean checkStrDate(String dateStr) {
        if (dateStr == null) return false;
        int five = 5;
        // Excel 5位数字（通常代表天数），尝试解析为 double 并转换为日期
        if (dateStr.length() == five) {
            try {
                double v = Double.parseDouble(dateStr);
                Date d = excelDoubleToDate(v);
                return d != null;
            } catch (Exception e) {
                log.debug("checkStrDate double parse failed: {}", dateStr);
                return false;
            }
        }

        // 尝试严格解析 yyyyMMdd
        try {
            LocalDate.parse(dateStr, YYYYMMDD_FORMATTER);
            return true;
        } catch (DateTimeParseException ignored) {
        }

        // 尝试解析中文格式 yyyy年MM月dd日
        try {
            LocalDate.parse(dateStr, YYYY_MM_DD_CHINESE_FORMATTER);
            return true;
        } catch (DateTimeParseException ignored) {
        }

        // 未能解析为已知格式
        return false;
    }

    /**
     * 将给定 java.util.Date 调整到当日开始或结束（兼容老实现 compareDate）。
     * compare: "start" 或其他（表示 end）。
     */
    public static java.util.Date compareDate(java.util.Date date, String compare) {
        if (date == null) return null;
        ZoneId zone = ZoneId.systemDefault();
        LocalDate localDate = date.toInstant().atZone(zone).toLocalDate();
        if ("start".equalsIgnoreCase(compare)) {
            LocalDateTime start = localDate.atStartOfDay();
            return java.util.Date.from(start.atZone(zone).toInstant());
        } else {
            LocalDateTime end = localDate.atTime(23, 59, 59, 999_000_000);
            return java.util.Date.from(end.atZone(zone).toInstant());
        }
    }

    // --- Hutool 兼容和历史遗留方法处理 ---
    // 如果这些方法在其他地方被广泛使用，且短时间内无法迁移，可以保留并优化内部实现。
    // 但最佳实践是直接替换为 java.time API 的等效方法。

    /**
     * 兼容 Hutool.DateUtil.parse 的方法，但内部使用 java.time
     * @param dateStr 日期字符串
     * @param pattern 格式模式
     * @return 解析后的 LocalDate
     */
    public static LocalDate parseDateWithPattern(String dateStr, String pattern) {
        if (dateStr == null || pattern == null) return null;
        try {
            return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(pattern));
        } catch (DateTimeParseException e) {
            log.error("解析日期字符串 {} 使用模式 {} 失败: {}", dateStr, pattern, e.getMessage());
            return null;
        }
    }

    // --- 原始 WeekListVo 相关的逻辑，需要 WeekListVo 类的定义来进一步完善 ---
    // 假设 WeekListVo 及其内部列表存储的是 String 格式的 yyyyMMdd
    @lombok.SneakyThrows // 不建议在生产代码中使用
    public static WeekListVo getWeekListV2(String beginDateStr, String endDateStr) {
        WeekListVo result = new WeekListVo();
        List<String> weekList = new ArrayList<>();
        List<String> weekStartList = new ArrayList<>();
        List<String> weekEndList = new ArrayList<>();
        List<String> weekStartLastList = new ArrayList<>();
        List<String> weekEndLastList = new ArrayList<>();

        if (beginDateStr == null || endDateStr == null) {
            log.warn("beginDateStr 或 endDateStr 为空，无法生成周列表");
            return result;
        }

        LocalDate beginDate = LocalDate.parse(beginDateStr, YYYYMMDD_FORMATTER);
        LocalDate endDate = LocalDate.parse(endDateStr, YYYYMMDD_FORMATTER);

        LocalDate currentWeekStart = LocalDate.parse(getCustomWeekStartDayInMonth(beginDateStr), YYYYMMDD_FORMATTER);
        LocalDate endWeekStart = LocalDate.parse(getCustomWeekStartDayInMonth(endDateStr), YYYYMMDD_FORMATTER);

        while (!currentWeekStart.isAfter(endWeekStart)) {
            String weekStartStr = currentWeekStart.format(YYYYMMDD_FORMATTER);
            String weekEndStr = getCustomWeekEndDayInMonth(weekStartStr); // 使用自定义周结束逻辑

            weekList.add(weekEndStr); // 根据原逻辑，weekList 存的是周结束日期
            weekStartList.add(weekStartStr);
            weekEndList.add(weekEndStr);

            // -1 日逻辑，这在周计算中比较特殊，需要确认其业务含义。这里只是简单沿用
            weekStartLastList.add(addDaysSpecial(weekStartStr, -1));
            weekEndLastList.add(addDaysSpecial(weekEndStr, -1));

            // 计算下一周的自定义起点：先尝试以 currentWeekStart + 7 天为候选，然后基于自定义规则重新规范化
            LocalDate candidate = currentWeekStart.plusDays(7);
            String candidateStartStr = candidate.format(YYYYMMDD_FORMATTER);
            String nextStartStr = getCustomWeekStartDayInMonth(candidateStartStr);
            LocalDate nextStart;
            try {
                nextStart = LocalDate.parse(nextStartStr, YYYYMMDD_FORMATTER);
            } catch (DateTimeParseException ex) {
                // 解析失败时作为保底直接使用 candidate
                nextStart = candidate;
            }

            // 如果计算出的 nextStart 没有前进（防止死循环），则直接使用 candidate 作为下一个起点
            if (!nextStart.isAfter(currentWeekStart)) {
                nextStart = candidate;
            }

            currentWeekStart = nextStart;
        }

        // 最后对 endDateStr 所在的周进行处理，因为上面的循环可能没有包含它
        if (!endDate.isBefore(beginDate) && !weekEndList.contains(getCustomWeekEndDayInMonth(endDateStr))) {
            String finalWeekStartStr = getCustomWeekStartDayInMonth(endDateStr);
            String finalWeekEndStr = getCustomWeekEndDayInMonth(endDateStr);
            weekList.add(finalWeekEndStr);
            weekStartList.add(finalWeekStartStr);
            weekEndList.add(finalWeekEndStr);
            weekStartLastList.add(addDaysSpecial(finalWeekStartStr, -1));
            weekEndLastList.add(addDaysSpecial(finalWeekEndStr, -1));
        }


        result.setWeekList(weekList);
        result.setWeekStartList(weekStartList);
        result.setWeekEndList(weekEndList);
        result.setWeekStartLastList(weekStartLastList);
        result.setWeekEndLastList(weekEndLastList);
        return result;
    }
}

